package com.base.core.framework.mybatis.service;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

import com.baomidou.mybatisplus.extension.service.IService;
import com.base.core.framework.mybatis.entity.BaseV1Ext;
import com.gitee.magic.framework.base.utils.ParamValue;
import com.gitee.magic.framework.head.vo.QueryVO;

/**
 * @author start
 * @param <T>
 */
public interface BaseService<T extends BaseV1Ext,PK extends Serializable> extends IService<T> {

	<P>Long saveForUpdate(PK pk,P param);
	
	/**
	 * 根据主键加载
	 * @param id
	 * @return
	 */
	T load(PK id);

	/**
	 * 获取列表数据的第一条记录，只能为一条数据
	 * @param collections
	 * @param <R>
	 * @return
	 */
	<R>R get(List<R> collections);

	/**
	 * 获取列表数据的第一条记录
	 * @param collections
	 * @param flag	true:表示只能为一条数据
	 * @param <R>
	 * @return
	 */
	<R>R get(List<R> collections,Boolean flag);
	
	/**
	 * Map转对象
	 * @param prototype
	 * @param data
	 * @return
	 */
	<R>R result(Class<R> prototype,Map<String,Object> data);
	
	/**
	 * List<Map>转对象列表
	 * @param prototype
	 * @param datas
	 * @return
	 */
	<R>List<R> result(Class<R> prototype,List<Map<String,Object>> datas);

	/**
	 * 分页List<Map>转对象列表
	 * @param prototype
	 * @param datas
	 * @param totalCount
	 * @param <R>
	 * @return
	 */
	<R>QueryVO<R> queryVO(Class<R> prototype,List<Map<String,Object>> datas,int totalCount);

	/**
	 * 分页List<Map>转对象列表
	 * @param results
	 * @param totalCount
	 * @param <R>
	 * @return
	 */
	<R>QueryVO<R> queryVO(List<R> results,int totalCount);
	
	
	
	/**
	 * 加载对象
	 * @param rpro
	 * @param param
	 * @param <R>
	 * @param <P>
	 * @return
	 */
	<R,P>R load(Class<R> rpro,P param);

	/**
	 * 加载对象
	 * @param rpro
	 * @param params
	 * @param <R>
	 * @return
	 */
	<R>R load(Class<R> rpro,List<ParamValue> params);

	/**
	 * 删除
	 * @param id
	 * @return
	 */
	int remove(PK id);

	/**
	 * 删除
	 * @param ids
	 * @return
	 */
	int remove(PK[] ids);

	/**
	 * 删除
	 * @param ids
	 * @return
	 */
	int remove(Collection<PK> ids);

	/**
	 * 查询对象
	 * @param ids
	 * @return
	 */
	List<T> queryForByIds(PK[] ids);

	/**
	 * 查询对象
	 * @param ids
	 * @return
	 */
	List<T> queryForByIds(Collection<PK> ids);

	/**
	 * 查询对象
	 * @param <R>
	 * @param rpro
	 * @param ids
	 * @return
	 */
	<R>List<R> queryForByIds(Class<R> rpro, Collection<PK> ids);

	/**
	 * 获取所有对象
	 * @return
	 */
	List<T> queryForAll();

	/**
	 * 获取所有对象
	 * @param rpro
	 * @param <R>
	 * @return
	 */
	<R> List<R> queryForAll(Class<R> rpro);

	/**
	 * 获取所有Map
	 * @return
	 */
	List<Map<String, Object>> queryForMapAll();

	/**
	 * 获取对象
	 * @param rpro
	 * @param param
	 * @param <R>
	 * @param <P>
	 * @return
	 */
	<R, P> List<R> queryForMap(Class<R> rpro, P param);

	/**
	 * 获取对象
	 * @param rpro
	 * @param params
	 * @param <R>
	 * @return
	 */
	<R> List<R> queryForMap(Class<R> rpro, Map<String, Object> params);
	
	/**
	 * 获取对象
	 * @param <R>
	 * @param rpro
	 * @param params
	 * @return
	 */
	<R> List<R> queryForMap(Class<R> rpro,List<ParamValue> params);

	/**
	 * 分页
	 * @param rpro
	 * @param param
	 * @param <R>
	 * @param <P>
	 * @return
	 */
	<R, P> QueryVO<R> pageWrapper(Class<R> rpro, P param);

	/**
	 * 分页
	 * @param rpro
	 * @param param
	 * @param pageIndex
	 * @param pageSize
	 * @param <R>
	 * @param <P>
	 * @return
	 */
	<R, P> QueryVO<R> pageWrapper(Class<R> rpro, P param,int pageIndex,int pageSize);

	/**
	 * 分页
	 * @param rpro
	 * @param params
	 * @param pageIndex
	 * @param pageSize
	 * @param <R>
	 * @return
	 */
	<R> QueryVO<R> pageWrapper(Class<R> rpro, List<ParamValue> params,int pageIndex,int pageSize);
	
	/**
	 * List转化为List
	 * @param <R>
	 * @param result
	 * @param resultMapper
	 * @return
	 */
	<R>List<T> streamToList(List<R> result,Function<R,PK> resultMapper);
	
	/**
	 * List转化为Map
	 * @param <R>
	 * @param result
	 * @param resultMapper
	 * @param valMapper
	 * @return
	 */
	<R>Map<PK,T> streamToMap(List<R> result,Function<R,PK> resultMapper,Function<T,PK> valMapper);
	
	/**
	 * List转化为MapGroupby
	 * @param <R>
	 * @param <KV>
	 * @param result
	 * @param resultMapper
	 * @param valMapper
	 * @return
	 */
	<R,KV> Map<KV, List<T>> streamToMapGroupingBy(List<R> result, Function<R, PK> resultMapper,Function<T, KV> valMapper);
	
	/**
	 * List转化为List
	 * @param <R>
	 * @param <P>
	 * @param result
	 * @param resultMapper
	 * @param rpro
	 * @return
	 */
	<R,P>List<P> streamToList(List<R> result,Function<R,PK> resultMapper,Class<P> rpro);
	
	/**
	 * List转化为Map
	 * @param <R>
	 * @param <P>
	 * @param result
	 * @param resultMapper
	 * @param rpro
	 * @param valMapper
	 * @return
	 */
	<R,P>Map<PK,P> streamToMap(List<R> result,Function<R,PK> resultMapper,Class<P> rpro,Function<P,PK> valMapper);
	
	/**
	 * List转化为MapGroupby
	 * @param <R>
	 * @param <P>
	 * @param <KV>
	 * @param result
	 * @param resultMapper
	 * @param rpro
	 * @param valMapper
	 * @return
	 */
	<R,P,KV>Map<KV, List<P>> streamToMapGroupingBy(List<R> result,Function<R,PK> resultMapper,Class<P> rpro,Function<P,KV> valMapper);
	
	
}
